The AI Amplification Effect: Why AI Makes Expert Auditors 10x Better and Novices 20x Worse

TL;DR: AI is the biggest force multiplier in security since the internet — but it amplifies what you already are. XBOW hit 85% accuracy in 28 minutes; the best human took 40 hours for the same score. Meanwhile, curl shut down its bug bounty because AI-generated garbage reports became unmanageable. Expert + AI = 10x. Novice + AI = catastrophe. The middle class of hacking is dead.

🔍 The Data That Changed My Mind About AI in Security

After 27 years in cybersecurity, I thought I’d seen every hype cycle. Neural networks in the 2010s. “Machine learning-powered” everything. Blockchain-will-solve-security promises.

Then XBOW happened.

In 2025, XBOW — an AI-powered vulnerability discovery system — achieved 85% accuracy on a standardized security benchmark in 28 minutes. The best human researcher? 85% accuracy in 40 hours. Same score, 85x faster. XBOW went on to discover 1,060 real vulnerabilities and hit #1 on HackerOne’s leaderboard.

That’s not incremental improvement. That’s a paradigm shift.

But here’s the part most people miss — and the reason I’m writing this. Within the same month that XBOW was making history, curl announced it was shutting down its bug bounty program. Not because they ran out of bugs. Because they were drowning in AI-generated garbage reports.

Same technology. Opposite results. That paradox is the most important thing happening in security right now.

⚡ The Amplification Effect: A Framework for Understanding AI in Security

Let me give you a mental model I use daily as Lead Security Auditor at Polygon Labs.

AI amplifies what you are.

If you’re an expert with deep knowledge of attack vectors, EVM internals, and years of pattern recognition — AI makes you 10x more effective. You ask the right questions. You recognize when AI output is wrong. You chain AI insights with your own experience to find vulnerabilities that neither you nor the AI would catch alone.

If you’re a novice with surface-level knowledge — AI makes you 20x worse. Not just “not better.” Actively worse. You generate confident-sounding reports full of false positives. You waste security teams’ time triaging garbage. You create noise that drowns out real signals. You develop a false sense of competence that stops you from actually learning.

This isn’t theory. I see it every week.

💀 The AI Slop Epidemic: Real Numbers, Real Damage

In February 2026, Daniel Stenberg — the creator and maintainer of curl — announced he was shutting down curl’s bug bounty program. His reason was blunt: AI-generated reports had made the program unsustainable.

The reports looked professional. They had proper formatting, technical terminology, CVE references. They were also completely wrong — fabricated vulnerabilities in code paths that didn’t exist, misidentified function behaviors, hallucinated attack vectors.

Immunefi — the largest Web3 bug bounty platform — implemented rate limiting on submissions for the same reason. The platform was flooded with AI-generated reports that consumed reviewer bandwidth without producing real findings.

I experience this personally. As someone active on Immunefi and in the Web3 bug bounty ecosystem, I receive and review reports regularly. The pattern is unmistakable: a report arrives with perfect English, proper structure, and a detailed “proof of concept” that fundamentally misunderstands how the contract actually works.

The reporter clearly pasted the code into ChatGPT and asked “find vulnerabilities.” The AI found patterns that look like vulnerabilities to a model trained on security literature, but aren’t actual bugs in context.

What AI-Generated Garbage Reports Look Like

Here’s a real pattern I see constantly. Take this contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract StakingVault is ReentrancyGuard {
    mapping(address => uint256) public stakes;
    mapping(address => uint256) public rewardDebt;
    uint256 public accRewardPerShare;
    IERC20 public stakingToken;
    IERC20 public rewardToken;

    function withdraw(uint256 amount) external nonReentrant {
        require(stakes[msg.sender] >= amount, "Insufficient stake");
        uint256 pending = (stakes[msg.sender] * accRewardPerShare / 1e12) - rewardDebt[msg.sender];
        
        stakes[msg.sender] -= amount;
        rewardDebt[msg.sender] = stakes[msg.sender] * accRewardPerShare / 1e12;
        
        rewardToken.transfer(msg.sender, pending);
        stakingToken.transfer(msg.sender, amount);
    }
}

An AI-generated report will flag this as “Critical: Reentrancy vulnerability — external calls before state updates.” The report will detail a reentrancy attack via the transfer() calls.

Except… the function has nonReentrant. The state updates happen before the transfers. And in Solidity 0.8+, arithmetic underflow is checked by default. The report is wrong on every count, but it sounds right if you don’t actually understand the code.

A novice reads this AI output and thinks they found a critical bug. An expert reads it and sees three reasons why it’s a false positive in the first five seconds.

🎯 What Experts Actually Do With AI (And Why It’s Different)

Let me show you the other side. Here’s how I use AI in my actual audit workflow.

When I review a complex DeFi protocol — say a lending market with custom oracle integration — I don’t ask AI “find vulnerabilities.” That’s the novice approach. Instead, I use AI to accelerate specific tasks where my expertise provides the context:

1. Code comprehension at scale. A protocol might have 15,000 lines of Solidity across 40 contracts. I use AI to map the architecture, trace call flows, and identify the critical paths — the functions that handle user funds, update state, or interact with external protocols. This used to take me a full day. Now it takes two hours, and I catch structural patterns I might have missed during manual review.

2. Pattern matching against known exploits. I’ve built AI-powered vulnerability hunting systems trained on thousands of real exploit patterns. When the AI flags something, I don’t just forward it as a finding. I verify it against the specific context: the Solidity version, the inheritance chain, the access controls, the interaction with other contracts. Context is everything.

3. Invariant generation. This is where AI genuinely shines when guided by expertise. I describe the economic invariants of a protocol — “total deposits should always equal total shares times share price” — and use AI to generate fuzzing campaigns that try to break them. The AI writes the harnesses; I define what “broken” means.

4. Cross-reference with historical exploits. “This oracle implementation looks similar to the one in Mango Markets before the $114M exploit. Let me check the specific assumptions about TWAP windows.” AI excels at this kind of pattern recall when you know what patterns to look for.

🛡️ What AI Catches vs. What It Misses: A Technical Deep Dive

Let’s get concrete. Here’s a contract with multiple issues — some that AI catches reliably, and some that require human expertise:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract LendingPool {
    mapping(address => uint256) public deposits;
    mapping(address => uint256) public borrows;
    
    IOracle public oracle;
    uint256 public constant COLLATERAL_FACTOR = 75; // 75%
    uint256 public totalDeposits;
    
    function deposit() external payable {
        deposits[msg.sender] += msg.value;
        totalDeposits += msg.value;
    }
    
    function borrow(uint256 amount) external {
        uint256 collateralValue = deposits[msg.sender] * oracle.getPrice() / 1e18;
        uint256 maxBorrow = collateralValue * COLLATERAL_FACTOR / 100;
        require(borrows[msg.sender] + amount <= maxBorrow, "Undercollateralized");
        
        borrows[msg.sender] += amount;
        (bool success, ) = msg.sender.call{value: amount}("");
        require(success, "Transfer failed");
    }
    
    function liquidate(address borrower) external {
        uint256 collateralValue = deposits[borrower] * oracle.getPrice() / 1e18;
        uint256 maxBorrow = collateralValue * COLLATERAL_FACTOR / 100;
        require(borrows[borrower] > maxBorrow, "Not liquidatable");
        
        // Liquidator repays debt and gets collateral
        uint256 debt = borrows[borrower];
        uint256 collateral = deposits[borrower];
        
        borrows[borrower] = 0;
        deposits[borrower] = 0;
        totalDeposits -= collateral;
        
        (bool success, ) = msg.sender.call{value: collateral}("");
        require(success, "Transfer failed");
    }
}

✅ What AI Catches Well

Reentrancy in borrow(): The external call (msg.sender.call) happens after state updates, but there’s no reentrancy guard. AI tools like Slither and Mythril catch this reliably. A borrower could re-enter and drain the pool.

Missing access control: The liquidate() function doesn’t require the liquidator to actually repay the debt — they just get the collateral for free. Any automated scanner flags this.

❌ What AI Misses (And Experts Catch)

Oracle manipulation: The contract uses oracle.getPrice() as a spot price. If the oracle reads from a DEX pool, an attacker can use a flash loan to manipulate the pool price, make their collateral appear more valuable, borrow against the inflated value, and repay the flash loan — all in one transaction. This is exactly how Mango Markets lost $114M. AI won’t flag this because it doesn’t understand the economic context of how the oracle gets its price.

Liquidation MEV and incentive design: The liquidation function gives 100% of collateral to the liquidator regardless of debt size. If someone has $1000 in collateral and $750 in debt, the liquidator gets $1000 and the borrower loses everything. This creates toxic liquidation cascades during market crashes. Understanding this requires DeFi experience, not just code analysis.

Cross-contract composability risks: If this pool’s deposit tokens are used as collateral in another protocol, a cascade of liquidations could drain both systems simultaneously. This is the class of vulnerability that caused the Cream Finance cascade in 2021 — $130M across multiple forks using the same vulnerable code.

The pattern is clear: AI catches syntactic bugs. Experts catch economic bugs, cross-protocol risks, and incentive misalignments. The most expensive hacks in DeFi history — Mango Markets ($114M), Cream Finance ($130M), Euler Finance ($197M) — were all economic logic failures, not code-level bugs.

💡 Why “The Middle Class of Hacking Is Dead”

Before AI, there was a large middle tier of security researchers and auditors. They weren’t world-class, but they were competent. They could find medium-severity bugs, write decent reports, and earn a living through bug bounties and audit firms.

AI killed that tier.

Here’s why: the bugs that middle-tier researchers used to find — the straightforward reentrancies, missing access controls, unchecked return values — are now found instantly by AI tools. Those findings are worth $0 in a world where Slither runs in seconds.

Meanwhile, the bugs that are still worth real money — complex economic attacks, cross-protocol interactions, oracle manipulation chains — require deep expertise that the middle tier never had.

The result is a barbell distribution:

On one end: experts with AI, earning more than ever. Immunefi reports $100M+ paid out in bounties, with top researchers earning $1M+ on single findings. The expert tier is thriving because AI handles the tedious parts and lets them focus on the creative, context-dependent work that machines can’t do alone.

On the other end: novices with AI, generating noise. Flooding bug bounty platforms with false positives. Getting rate-limited. Getting banned. Creating so much garbage that programs like curl’s shut down entirely.

The middle? Gone. If your main skill was “I can read Solidity and find basic bugs,” AI just commoditized you. You need to go up or get out.

🔥 XBOW vs. curl: The Same Technology, Opposite Results

Let me break down why XBOW succeeded where thousands of AI-assisted novices failed. It comes down to one word: context.

XBOW wasn’t built by someone who typed “find bugs” into GPT-4. It was built by security researchers who encoded years of exploit knowledge, vulnerability taxonomies, and attack methodologies into the system’s architecture. The AI wasn’t replacing expertise — it was executing it at machine speed.

The 1,060 vulnerabilities XBOW found were real because the system understood what real vulnerabilities look like. Not from reading about them — from having been built by people who found them manually for years.

Compare that to the curl reports. Someone with no security background asked an LLM to “audit curl for vulnerabilities.” The LLM generated plausible-sounding reports because it was trained on security literature. But without understanding the actual codebase, the compilation context, the platform-specific behaviors, and the historical decisions behind the code — the output was worse than useless. It was actively harmful, consuming developer time and creating alert fatigue.

I’ve built AI-powered vulnerability hunting systems with thousands of real exploit patterns. The difference between my tools and a novice prompting ChatGPT isn’t the AI model — we might literally use the same underlying model. The difference is the expert context layered on top. What patterns to look for. What constitutes a real finding versus a theoretical issue. How to chain findings into actual exploits. How to prioritize based on real-world impact.

AI alone performs average at best. Feed it expert context and the results are mindblowing.

⚡ What This Means for the Future of Smart Contract Auditing

Here’s my prediction based on what I’m seeing now, working at the intersection of AI and smart contract security:

Automated scanning becomes table stakes. Every protocol will run AI-powered analysis before any human looks at the code. This is already happening. The protocols I audit at Polygon Labs have usually run Slither, Aderyn, and custom AI tools before I get involved. My job isn’t to find what those tools find — it’s to find what they miss.

Expert auditors become more valuable, not less. As automated tools handle the low-hanging fruit, the remaining bugs are harder, more complex, and more impactful. Finding them requires deeper expertise. The market is already reflecting this — top audit firms are charging more, not less, than they did two years ago.

The barrier to entry gets both lower and higher simultaneously. Lower because AI helps beginners learn faster — you can ask Claude to explain a complex vulnerability pattern and get a detailed walkthrough. Higher because the minimum competence to add value keeps rising as AI handles the easy stuff.

Bug bounty programs will bifurcate. We’ll see two tiers: open programs with heavy AI filtering (automated triage, duplicate detection, quality scoring) and invite-only programs for verified experts. The middle-ground “submit whatever you find” model is dying — curl proved that.

🎯 The Question Isn’t Whether to Use AI — It’s Whether You Have the Expertise to Make It Useful

I’ve been in cybersecurity since 1999. I’ve worked at Spain’s national cybersecurity institute (INCIBE), at Telefónica, co-founded a DeFi protocol that handled $30M in deposits and was never hacked despite Lazarus-level attacks, earned a PhD researching blockchain security, and now lead security at Polygon Labs.

AI is the biggest force multiplier I’ve seen in 27 years. But a force multiplier multiplies the force you already have.

If you understand reentrancy at a deep level — not just “external call before state update” but the ERC-777 callback variant that hit Cream Finance, the cross-contract variant that hit Hundred Finance, the read-only reentrancy in view functions that breaks composability — then AI helps you check for all those variants across a massive codebase in minutes instead of days.

If you don’t understand those nuances, AI will tell you “this function has an external call” and you’ll either miss the real bug or flag a false positive. Either way, you’re not adding value.

The gap between experts and amateurs has become so vast that mediocrity is no longer viable. In 2020, you could be a decent Solidity reader with some security knowledge and find enough bugs to make a living. In 2026, that niche doesn’t exist. You’re either an expert using AI to be extraordinary, or you’re generating noise.

The fundamentals haven’t changed — Checks-Effects-Interactions, proper access control, oracle security, economic invariant testing. What’s changed is that you need those fundamentals plus the ability to leverage AI effectively. One without the other gets you nowhere.

The question for every security professional in 2026 isn’t “should I use AI?” — everyone uses AI. The question is: “Do I have the expertise that makes AI actually useful?”

Your answer to that question determines which side of the amplification effect you’re on.

⚡ XBOW found 1,060 real vulnerabilities and hit #1 on HackerOne. curl shut down its bug bounty because of AI-generated garbage. Same technology, opposite results. The difference isn’t AI — everyone has AI. The difference is the security expertise underneath. That’s exactly what the Master Program teaches.

❓ Frequently Asked Questions

Can AI replace human smart contract auditors?
No. AI catches syntactic bugs and known patterns, but the most expensive DeFi hacks — Mango Markets ($114M), Euler Finance ($197M) — involved economic logic flaws that require human understanding of market mechanics, cross-protocol composability, and incentive design. AI is a force multiplier for experts, not a replacement.

What is the AI amplification effect in security?
The AI amplification effect describes how AI magnifies existing skill levels: experts become 10x more effective because they provide the right context and verify AI output, while novices become actively harmful because they generate confident-sounding but incorrect vulnerability reports that waste everyone’s time.

Why did curl shut down its bug bounty program?
In February 2026, curl shut down its bug bounty program because AI-generated vulnerability reports became unmanageable. The reports were well-formatted but fundamentally wrong — fabricating vulnerabilities in nonexistent code paths and hallucinating attack vectors. The signal-to-noise ratio made the program unsustainable.

What tools do expert auditors use with AI in 2026?
Expert auditors combine traditional tools (Foundry, Slither, Mythril, Aderyn) with AI for code comprehension at scale, invariant generation for fuzzing campaigns, pattern matching against known exploits, and cross-referencing with historical attack data. The key difference is providing expert context to AI, not just asking it to “find bugs.”

How do I avoid being on the wrong side of AI amplification?
Build deep security fundamentals first: understand EVM internals, master Solidity security patterns, study real exploits in detail (DeFiHackLabs is excellent for this), and practice on audit competitions (Sherlock, Code4rena, Cantina). Then layer AI tools on top of that foundation. The Master Program at Blockchain White Hackers teaches exactly this progression.